// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()
// 导入数据库操作模块
const db = require('../db/index')
// 导入验证数据合法性的中间件
const expressJoi = require('@escook/express-joi')
// 导入需要的验证规则对象
const {
  add_userinfo_schema,
  update_userinfo_schema,
  update_password_schema,
} = require('../schema/user')
// 使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
const bcrypt = require('bcryptjs')

// 根据token中的user.id获取当前用户的基本信息
router.get('/userinfo', (req, res) => {
  console.log(req.user, '111111111111')
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, phone,role from user where id=?`
  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  db.query(sql, req.user.id, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err)

    // 2. 执行 SQL 语句成功，但是查询到的数据条数不等于 1
    if (results.length !== 1) return res.cc('获取用户信息失败！')

    // 3. 将用户信息响应给客户端
    res.send({
      code: 200,
      message: '获取当前用户基本信息成功！',
      data: results[0],
    })
  })
  // res.send('ok')
})

// 根据id获取用户的基本信息
router.get('/userinfo/:id', (req, res) => {
  console.log(req.user, '111111111111')
  console.log(req.params, '222222222')
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, phone,role from user where id=?`
  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  db.query(sql, req.params.id, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err)

    // 2. 执行 SQL 语句成功，但是查询到的数据条数不等于 1
    if (results.length !== 1) return res.cc('获取用户信息失败！')

    // 3. 将用户信息响应给客户端
    res.send({
      code: 200,
      message: '获取用户基本信息成功！',
      data: results[0],
    })
  })
  // res.send('ok')
})

// 获取 所有用户信息
router.get('/userinfoAll', (req, res) => {
  console.log(req.user, '2222')
  console.log(req.query, '3333')
  // 偏移量
  const pages = req.query.pagesize * (req.query.pagenum - 1)
  console.log(pages)
  // if(pages >= )
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  // const sql = `select * from user`

  if (req.query.query) {
    var sql = `select * from user where username like "%${
      req.query.query
    }%" limit ${(pages, req.query.pagesize)};`
  } else {
    // var sql = `select * from user limit ${pages},${req.query.pagesize}`
    var sql = `select * from user`
  }
  // const sql = `select * from user where username like "%${req.query.query}%";`
  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err + 'sql语句执行失败')

    // 2. 执行 SQL 语句成功，但是查询到的数据条数不等于 1
    if (results.length < 1) return res.cc('获取用户信息失败！')

    // 3. 将用户信息响应给客户端
    res.send({
      code: 200,
      message: '获取全部用户基本信息成功！',
      data: results,
      total: results.length,
    })
  })
  // res.send('ok')
})

// 更新用户的基本信息
router.post('/userinfo/:id', expressJoi(update_userinfo_schema), (req, res) => {
  const sql = `update user set ? where id=?`
  console.log(req.params, ',,,,,,,,,,,,,,,')
  db.query(sql, [req.body, req.params.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)

    // 执行 SQL 语句成功，但影响行数不为 1
    if (results.affectedRows !== 1) return res.cc('修改用户基本信息失败！')

    // 修改用户信息成功
    res.send({
      code: 200,
      message: '修改用户基本信息成功！',
    })
  })
  // res.send('ok')
})

// 添加用户信息
router.post('/addUserinfo', expressJoi(add_userinfo_schema), (req, res) => {
  console.log(req.body, 'add|add')
  // 接收表单数据
  const userinfo = req.body
  console.log(userinfo, '+++++++++++++++')
  // 判断数据是否合法
  if (!userinfo.username || !userinfo.password) {
    return res.send({ code: 400, message: '用户名或密码不能为空！' })
  }

  const sql = `select * from user where username=?`
  db.query(sql, [userinfo.username], function (err, results) {
    // 执行 SQL 语句失败
    if (err) {
      return res.send({ code: 400, message: err.message })
    }
    // 用户名被占用
    if (results.length > 0) {
      return res.send({
        code: 400,
        message: '用户名被占用，请更换其他用户名！',
      })
    }
    // TODO: 用户名可用，继续后续流程...
    // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
    userinfo.password = bcrypt.hashSync(userinfo.password, 10)

    const sql = 'insert into user set ?'
    db.query(
      sql,
      {
        username: userinfo.username,
        password: userinfo.password,
        phone: userinfo.phone,
        nickname: userinfo.nickname,
        role: userinfo.role,
      },
      function (err, results) {
        // 执行 SQL 语句失败
        if (err) return res.send({ code: 400, message: err.message })
        // SQL 语句执行成功，但影响行数不为 1
        if (results.affectedRows !== 1) {
          return res.send({ code: 400, message: '添加用户失败，请稍后再试！' })
        }
        // 注册成功
        res.send({ code: 200, message: '添加成功！' })
      }
    )
  })
})
// 根据id删除用户信息
router.delete('/userinfo/:id', (req, res) => {
  // 定义根据 id 删除用户数据的 SQL 语句
  const sql = `delete from user where id=?`
  db.query(sql, req.params.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err.message)
    // SQL 语句执行成功，但影响行数不为 1
    if (results.affectedRows !== 1) {
      // return res.send({ code: 400, message: '添加用户失败，请稍后再试！' })
      return res.cc('删除用户失败，请稍后再试！')
    }

    // 删除成功
    res.send({
      code: 200,
      message: '删除用户信息成功！',
    })
  })
})

// 重置密码的路由
router.post(
  '/updatepwd/:id',
  expressJoi(update_password_schema),
  (req, res) => {
    // 定义根据 id 查询用户数据的 SQL 语句
    const sql = `select * from user where id=?`

    // 执行 SQL 语句查询用户是否存在
    db.query(sql, req.params.id, (err, results) => {
      // 执行 SQL 语句失败
      if (err) return res.cc(err)

      // 检查指定 id 的用户是否存在
      if (results.length !== 1) return res.cc('用户不存在！')

      // // 判断提交的旧密码是否正确
      // const compareResult = bcrypt.compareSync(
      //   req.body.oldPwd,
      //   results[0].password
      // )
      // if (!compareResult) return res.cc('原密码错误！')

      // 定义更新用户密码的 SQL 语句
      const sql = `update user set password=? where id=?`

      // 对新密码进行 bcrypt 加密处理
      const newPwd = bcrypt.hashSync(req.body.password, 10)

      // 执行 SQL 语句，根据 id 更新用户的密码
      db.query(sql, [newPwd, req.params.id], (err, results) => {
        // SQL 语句执行失败
        if (err) return res.cc(err)

        // SQL 语句执行成功，但是影响行数不等于 1
        if (results.affectedRows !== 1) return res.cc('更新密码失败！')

        // 更新密码成功
        res.cc('更新密码成功！', 200)
      })
    })
    // res.send('ok')
  }
)

router.get('/roles', (req, res) => {
  // 定义根据 id 删除用户数据的 SQL 语句
  const sql = `select DISTINCT role from user`
  db.query(sql, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err.message)
    // SQL 语句执行成功，但影响行数不为 1
    if (results.length < 1) {
      // return res.send({ code: 400, message: '添加用户失败，请稍后再试！' })
      return res.cc('用户角色查询失败，请稍后再试！')
    }

    // 用户角色查询成功
    res.send({
      code: 200,
      data: results,
      message: '用户角色查询成功！',
    })
  })
})

//根据id分配用户角色
router.get('/userinfoRole/:id', (req, res) => {
  // 定义根据 id 删除用户数据的 SQL 语句
  const sql = `update user set role= ? where id=?`
  console.log(req.query, req.params, 'userinfoRole----')
  db.query(sql, [req.query.role, req.params.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err.message)
    // SQL 语句执行成功，但影响行数不为 1
    if (results.affectedRows !== 1) {
      // return res.send({ code: 400, message: '添加用户失败，请稍后再试！' })
      return res.cc('用户角色分配失败，请稍后再试！')
    }

    // 用户角色查询成功
    res.send({
      code: 200,
      message: '用户角色分配成功！',
    })
  })
})

// 向外共享路由对象
module.exports = router
